/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package pkg.iss.model;

import java.net.DatagramPacket;
import java.nio.Buffer;
import java.util.List;
import java.util.Random;

/**
 *
 * @author LONPC
 */
public class Intersection {

    private int[][] intersection;
    private DatagramPacket packet;
    public List<Integer>[] fila;
    
    
    public Intersection(){
        this.intersection = new int[2][2];
        this.fila = new List[3];
    }

    public int[][] getIntersection() {
        return intersection;
    }

    public void setIntersection(int[][] intersection) {
        this.intersection = intersection;
    }

    //método de teste para tentativa de atravessar o cruzamento
     public byte[] attemptCrossing(){
            String a = "";
            intersection[0][0] = 1;
            intersection[0][1] = 0;
            intersection[1][0] = 1;
            intersection[1][1] = 0;
            this.setIntersection(intersection);
            for(int i=0; i<2; i++){            
                for(int j=0; j<2; j++){
                   a = a.concat(Integer.toString(intersection[i][j]));
                   
                }
            }           

        byte[] intersectionByte = a.getBytes();
        packet = new DatagramPacket(intersectionByte, intersectionByte.length);
        return intersectionByte;
    }

    //método que analisa o pedido de outro veículo para fazer o cruzamento 
    public String requisitionCrossing(String m) {
        int[][] matrixTemp = intersection; //armazena a matriz em outra temporária para não alterá-la antes de efetivar a transação
        byte[] data = new byte[1024];
        String aux = null;
        //método receiveMatrix pega o pacote e transforma em uma matriz[2][2]
        int[][] matrix = receiveMatrix(m);
        //laços para varrer a matriz inteira    
       int a=0;
        for(int i=0; i<2; i++){            
            for(int j=0; j<2; j++){
                System.out.println(matrix[i][j]);
                /*a matriz enviada pelo outro veículo tem valores diferentes de 0 apenas na posiçao
                 que ele deseja utilizar, se a matriz local for igual a 0 na posição onde ele deseja
                 utilizar essa posição é alocada para o veículo que requisitou, se todas as posições
                 desejadas estiverem livres então é retornado a mensagem de accepted para o requisitor
                 através de packet.
                 Mas caso qualquer uma das posições desejadas já estiver alocada, é proibido a passagem e
                 a matriz local continua inalterada.*/
                if (matrix[i][j] != 0 && intersection[i][j] == 0) {
                    matrixTemp[i][j] = matrix[i][j];
                } else if (matrix[i][j] != 0 && intersection[i][j] != 0) {
                    fila[a].add(matrix[i][j]);
                    System.out.println("Crossing Denied");
                    aux = "denied".toUpperCase();
                    
                    //caso alguma posição já esteja ocupada é retornado o packet para probir a passagem
                    return aux;
                }
                a++;
            }

        }
        aux = "accepted".toUpperCase();
       
        //altera a matriz e envia a mensagem de aceito
        intersection = matrixTemp;
        System.out.println("Crossing Accepted");
        return aux;

    }

    //método para desalocar a matriz depois que um carro passou
    private void crossingIntersection(String m) {
        int[][] matrix=receiveMatrix(m);
        int a=0;
        for(int i=0; i<2; i++){            
            for(int j=0; j<2; j++){
                if(matrix[i][j]!=0 && intersection[i][j]!=0){
                    if(fila[a].isEmpty()){
                        intersection[i][j]=0;
                    }
                    else{
                        intersection[i][j]=fila[a].get(0);
                        fila[a].remove(0);
                    }
                    
                }
                a++;
            }

        }
        System.out.println("Travessia efetuada e posição liberada");
        printIntersection();
    }
    //método para fazer a leitura de uma matriz ao receber ela como um packet
    public int[][] receiveMatrix(String m){
        int[][] matrix= new int[2][2];
        System.out.println(m);
        System.out.println("aqui");
        
        int l=0;
        for(int i=0; i<2;i++){
            for(int j=0; j<2; j++){
                System.out.println(m.charAt(l));
                matrix[i][j]=(int)m.charAt(l);
                l++;
            }
        }
        return matrix;
    }

    //método para o sorteio da matriz que irá indicar para o onde o carro deverá ir
    public int[][] sortitionMatrix(int car){
        int[][] aux=null;
        Random random = new Random();
        int i = random.nextInt(2);

        int[][] a11 = new int[2][2];
        a11[0][0] = 1;
        a11[0][1] = 0;
        a11[1][0] = 0;
        a11[1][1] = 0;

        int[][] a12 = new int[2][2];
        a11[0][0] = 1;
        a11[0][1] = 0;
        a11[1][0] = 1;
        a11[1][1] = 0;

        int[][] a13 = new int[2][2];
        a11[0][0] = 1;
        a11[0][1] = 0;
        a11[1][0] = 1;
        a11[1][1] = 1;

        int[][] b21 = new int[2][2];
        a11[0][0] = 0;
        a11[0][1] = 0;
        a11[1][0] = 2;
        a11[1][1] = 0;

        int[][] b22 = new int[2][2];
        a11[0][0] = 0;
        a11[0][1] = 0;
        a11[1][0] = 2;
        a11[1][1] = 2;

        int[][] b23 = new int[2][2];
        a11[0][0] = 0;
        a11[0][1] = 2;
        a11[1][0] = 2;
        a11[1][1] = 2;

        int[][] c31 = new int[2][2];
        a11[0][0] = 0;
        a11[0][1] = 3;
        a11[1][0] = 0;
        a11[1][1] = 0;

        int[][] c32 = new int[2][2];
        a11[0][0] = 3;
        a11[0][1] = 3;
        a11[1][0] = 0;
        a11[1][1] = 0;

        int[][] c33 = new int[2][2];
        a11[0][0] = 3;
        a11[0][1] = 3;
        a11[1][0] = 3;
        a11[1][1] = 0;

        int[][] d41 = new int[2][2];
        a11[0][0] = 0;
        a11[0][1] = 0;
        a11[1][0] = 0;
        a11[1][1] = 4;

        int[][] d42 = new int[2][2];
        a11[0][0] = 0;
        a11[0][1] = 4;
        a11[1][0] = 0;
        a11[1][1] = 4;

        int[][] d43 = new int[2][2];
        a11[0][0] = 4;
        a11[0][1] = 4;
        a11[1][0] = 0;
        a11[1][1] = 4;
        if (car == 1) {

            switch (i) {
                case 1:
                    System.out.println("O veículo A1 irá fazer uma conversão à direita ");
                    return aux = a11;
                case 2:
                    System.out.println("O veículo A1 vai seguir em frente");
                    return aux = a12;
                case 3:
                    System.out.println("O veículo A1 irá fazer uma conversão à esquerda");
                    return aux = a13;
            }
        }
        if (car == 2) {
            switch (i) {
                case 3:
                    System.out.println("O veículo A2 irá fazer uma conversão à direita ");
                    return aux = b21;
                case 4:
                    System.out.println("O veículo A2 vai seguir em frente");
                    return aux = b22;
                case 5:
                    System.out.println("O veículo A2 irá fazer uma conversão à esquerda");
                    return aux = b23;
            }
        }

        if (car == 3) {
            switch (i) {
                case 6:
                    System.out.println("O veículo A3 irá fazer uma conversão à direita ");
                    return aux = c31;
                case 7:
                    System.out.println("O veículo A3 vai seguir em frente");
                    return aux = c32;
                case 8:
                    System.out.println("O veículo A3 irá fazer uma conversão à esquerda");
                    return aux = c33;
            }
        }

        if (car == 4) {
            switch (i) {
                case 9:
                    System.out.println("O veículo A4 irá fazer uma conversão à direita ");
                    return aux = d41;
                case 10:
                    System.out.println("O veículo A4 vai seguir em frente");
                    return aux = d42;
                case 11:
                    System.out.println("O veículo A4 irá fazer uma conversão à esquerda");
                    return aux = d43;
            }
        }
        return aux;
    }

    public void printIntersection() {
        String a="  ",b="  ",c="  ",d="  ";
        
        if(intersection[0][0]==1){
            a="A1";
        }
        if(intersection[0][1]==3){
            c="C3";
        }if(intersection[1][0]==2){
            b="B2";
        }if(intersection[1][1]==4){
            d="D4";
        }
        System.out.println("    |    |\n    |"+ a+ "  |\n____      ___\n           "+c+"\n"+b+"\n___      ____\n    |  "+d+"|\n    |    |");
    }
}
